home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / front.lha / front / m2c / Oper.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  7KB  |  332 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_Lists
  4. #include "Lists.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_Strings
  8. #include "Strings.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Idents
  12. #include "Idents.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_Memory
  16. #include "Memory.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Positions
  20. #include "Positions.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_TokenTab
  24. #include "TokenTab.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Errors
  28. #include "Errors.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Oper
  32. #include "Oper.h"
  33. #endif
  34.  
  35.  
  36. #define eNoIntCode    25
  37. #define eTokenOverflow    26
  38. #define eNoTerm    40
  39. #define eTokenInPrio    35
  40. typedef struct S_1 *Priorities;
  41. typedef struct S_2 *Operators;
  42. typedef struct S_1 {
  43.     Oper_OperKind Kind;
  44.     TokenTab_PosType KindPos;
  45.     Operators List;
  46.     Lists_tList Comment;
  47.     TokenTab_PosType CommPos;
  48.     Priorities Next;
  49. } Priority;
  50. typedef struct S_2 {
  51.     TokenTab_Vocabulary Token;
  52.     TokenTab_PosType TokenPos;
  53.     Operators List;
  54. } Operator;
  55. static struct S_3 {
  56.     TokenTab_PosType OPERPos;
  57.     Lists_tList Comment;
  58.     TokenTab_PosType CommPos;
  59. } OperVars;
  60. static BOOLEAN ReadyForOperator;
  61. static Priorities WPrio;
  62. static Priorities StartPrio;
  63. static Priorities RPrio;
  64. static BOOLEAN INTOPERExists;
  65. static TokenTab_Prio CurrentPrio;
  66. static Operators WOp, ROp;
  67. static BOOLEAN GetOperatorAllowed;
  68. static BOOLEAN OpenForReading;
  69. static void ERROR ARGS((CHAR a[], LONGCARD ));
  70.  
  71.  
  72. void Oper_MakePriority
  73. # ifdef __STDC__
  74. (Oper_OperKind Kind, TokenTab_PosType Pos)
  75. # else
  76. (Kind, Pos)
  77. Oper_OperKind Kind;
  78. TokenTab_PosType Pos;
  79. # endif
  80. {
  81.   Priorities HPrio;
  82.  
  83.   if (OpenForReading) {
  84.     ERROR((STRING)"MakePriority : Do not write now ", 32L);
  85.   }
  86.   ReadyForOperator = TRUE;
  87.   HPrio = (Priorities)Memory_Alloc((LONGINT)sizeof(Priority));
  88.   if (HPrio == NIL) {
  89.     ERROR((STRING)"MakePriority : Heap overflow", 28L);
  90.   }
  91.   HPrio->Kind = Kind;
  92.   HPrio->KindPos = Pos;
  93.   HPrio->List = NIL;
  94.   WOp = NIL;
  95.   HPrio->Next = NIL;
  96.   Lists_MakeList(&HPrio->Comment);
  97.   HPrio->CommPos.Line = 0;
  98.   HPrio->CommPos.Column = 0;
  99.   if (WPrio != NIL) {
  100.     WPrio->Next = HPrio;
  101.   } else {
  102.     StartPrio = HPrio;
  103.   }
  104.   WPrio = HPrio;
  105.   INC(CurrentPrio);
  106. }
  107.  
  108. void Oper_CompletePriority
  109. # ifdef __STDC__
  110. (Lists_tList Comment, TokenTab_PosType CommPos)
  111. # else
  112. (Comment, CommPos)
  113. Lists_tList Comment;
  114. TokenTab_PosType CommPos;
  115. # endif
  116. {
  117.   if (!ReadyForOperator) {
  118.     ERROR((STRING)"CompletePriority : Wrong use of procedure", 41L);
  119.   }
  120.   if (OpenForReading) {
  121.     ERROR((STRING)"CompletePriority : Do not write now", 35L);
  122.   }
  123.   WPrio->Comment = Comment;
  124.   WPrio->CommPos = CommPos;
  125.   ReadyForOperator = FALSE;
  126. }
  127.  
  128. void Oper_MakeOperator
  129. # ifdef __STDC__
  130. (Idents_tIdent Token, TokenTab_PosType TokenPos)
  131. # else
  132. (Token, TokenPos)
  133. Idents_tIdent Token;
  134. TokenTab_PosType TokenPos;
  135. # endif
  136. {
  137.   Operators HOper;
  138.   TokenTab_Vocabulary HToken;
  139.   TokenTab_TokenError Error;
  140.   TokenTab_Terminal ter;
  141.  
  142.   if (!ReadyForOperator) {
  143.     ERROR((STRING)"makeOperator : Wrong use of procedure", 37L);
  144.   }
  145.   HToken = TokenTab_SymbolToToken(Token, &Error);
  146.   if (Error == TokenTab_NotExists) {
  147.     HToken = TokenTab_MAXTerm + 1;
  148.     if (HToken > TokenTab_cMAXTerm) {
  149.       Errors_ErrorMessage((LONGCARD)eTokenOverflow, (LONGCARD)Errors_eRestriction, TokenPos);
  150.     }
  151.     ter = HToken;
  152.     TokenTab_MakeTerm(Token, &ter, &Error, TokenPos);
  153.     if (Error == TokenTab_OutOfRange) {
  154.       Errors_ErrorMessage((LONGCARD)eTokenOverflow, (LONGCARD)Errors_eRestriction, TokenPos);
  155.     }
  156.   } else if (Error == TokenTab_NoIntCode) {
  157.     Errors_ErrorMessageI((LONGCARD)eNoIntCode, (LONGCARD)Errors_eFatal, Positions_NoPosition, (LONGCARD)Errors_eIdent, ADR(Token));
  158.   }
  159.   if (TokenTab_GetTokenType(HToken) != TokenTab_Term) {
  160.     Errors_ErrorMessageI((LONGCARD)eNoTerm, (LONGCARD)Errors_eError, TokenPos, (LONGCARD)Errors_eIdent, ADR(Token));
  161.   } else if (TokenTab_GetPrio(HToken) != 0) {
  162.     Errors_ErrorMessageI((LONGCARD)eTokenInPrio, (LONGCARD)Errors_eError, TokenPos, (LONGCARD)Errors_eIdent, ADR(Token));
  163.   } else {
  164.     TokenTab_PutPrio(TokenTab_SymbolToToken(Token, &Error), CurrentPrio);
  165.     HOper = (Operators)Memory_Alloc((LONGINT)sizeof(Operator));
  166.     if (HOper == NIL) {
  167.       ERROR((STRING)"MakeOperator : Heap Overflow", 28L);
  168.     }
  169.     HOper->Token = TokenTab_SymbolToToken(Token, &Error);
  170.     HOper->TokenPos = TokenPos;
  171.     HOper->List = NIL;
  172.     if (WOp != NIL) {
  173.       WOp->List = HOper;
  174.     } else {
  175.       WPrio->List = HOper;
  176.     }
  177.     WOp = HOper;
  178.   }
  179. }
  180.  
  181. void Oper_MakeOperHeader
  182. # ifdef __STDC__
  183. (TokenTab_PosType OPERPos, Lists_tList Comment, TokenTab_PosType CommPos)
  184. # else
  185. (OPERPos, Comment, CommPos)
  186. TokenTab_PosType OPERPos;
  187. Lists_tList Comment;
  188. TokenTab_PosType CommPos;
  189. # endif
  190. {
  191.   OperVars.OPERPos = OPERPos;
  192.   OperVars.Comment = Comment;
  193.   OperVars.CommPos = CommPos;
  194.   INTOPERExists = TRUE;
  195. }
  196.  
  197. void Oper_InitPrioReading
  198. # ifdef __STDC__
  199. ()
  200. # else
  201. ()
  202. # endif
  203. {
  204.   OpenForReading = TRUE;
  205.   RPrio = StartPrio;
  206. }
  207.  
  208. BOOLEAN Oper_GetOperHeader
  209. # ifdef __STDC__
  210. (TokenTab_PosType *OPERPos, Lists_tList *Comment, TokenTab_PosType *CommPos)
  211. # else
  212. (OPERPos, Comment, CommPos)
  213. TokenTab_PosType *OPERPos;
  214. Lists_tList *Comment;
  215. TokenTab_PosType *CommPos;
  216. # endif
  217. {
  218.   if (INTOPERExists) {
  219.     *OPERPos = OperVars.OPERPos;
  220.     *Comment = OperVars.Comment;
  221.     *CommPos = OperVars.CommPos;
  222.   } else {
  223.     OPERPos->Line = 0;
  224.     OPERPos->Column = 0;
  225.     Lists_MakeList(Comment);
  226.     CommPos->Line = 0;
  227.     CommPos->Column = 0;
  228.   }
  229.   return INTOPERExists;
  230. }
  231.  
  232. BOOLEAN Oper_GetPriority
  233. # ifdef __STDC__
  234. (Oper_OperKind *Kind, TokenTab_PosType *Pos, Lists_tList *Comment, TokenTab_PosType *CommPos)
  235. # else
  236. (Kind, Pos, Comment, CommPos)
  237. Oper_OperKind *Kind;
  238. TokenTab_PosType *Pos;
  239. Lists_tList *Comment;
  240. TokenTab_PosType *CommPos;
  241. # endif
  242. {
  243.   if (!OpenForReading) {
  244.     ERROR((STRING)"GetPriority : You must not read now", 35L);
  245.   }
  246.   if (RPrio == NIL) {
  247.     GetOperatorAllowed = FALSE;
  248.     return FALSE;
  249.   } else {
  250.     *Kind = RPrio->Kind;
  251.     *Pos = RPrio->KindPos;
  252.     *Comment = RPrio->Comment;
  253.     *CommPos = RPrio->CommPos;
  254.     ROp = RPrio->List;
  255.     RPrio = RPrio->Next;
  256.     GetOperatorAllowed = TRUE;
  257.     return TRUE;
  258.   }
  259. }
  260.  
  261. BOOLEAN Oper_GetOperator
  262. # ifdef __STDC__
  263. (TokenTab_Vocabulary *Token, TokenTab_PosType *TokenPos)
  264. # else
  265. (Token, TokenPos)
  266. TokenTab_Vocabulary *Token;
  267. TokenTab_PosType *TokenPos;
  268. # endif
  269. {
  270.   if (!GetOperatorAllowed) {
  271.     ERROR((STRING)"GetOperator : Wrong use of procedure", 36L);
  272.   }
  273.   if (ROp == NIL) {
  274.     return FALSE;
  275.   } else {
  276.     *Token = ROp->Token;
  277.     *TokenPos = ROp->TokenPos;
  278.     ROp = ROp->List;
  279.     return TRUE;
  280.   }
  281. }
  282.  
  283. static void ERROR
  284. # ifdef __STDC__
  285. (CHAR a[], LONGCARD O_1)
  286. # else
  287. (a, O_1)
  288. CHAR a[];
  289. LONGCARD O_1;
  290. # endif
  291. {
  292.   Strings_tString s;
  293.   OPEN_ARRAY_LOCALS
  294.  
  295.   ALLOC_OPEN_ARRAYS(O_1 * sizeof(CHAR), 1)
  296.   COPY_OPEN_ARRAY(a, O_1, CHAR)
  297.   Strings_ArrayToString(a, O_1, &s);
  298.   Errors_ErrorMessageI((LONGCARD)Errors_eInternal, (LONGCARD)Errors_eFatal, Positions_NoPosition, (LONGCARD)Errors_eString, ADR(s));
  299.   FREE_OPEN_ARRAYS
  300. }
  301.  
  302. void BEGIN_Oper()
  303. {
  304.   static BOOLEAN has_been_called = FALSE;
  305.  
  306.   if (!has_been_called) {
  307.     has_been_called = TRUE;
  308.  
  309.     BEGIN_Lists();
  310.     BEGIN_TokenTab();
  311.     BEGIN_Idents();
  312.     BEGIN_Lists();
  313.     BEGIN_Strings();
  314.     BEGIN_Idents();
  315.     BEGIN_Memory();
  316.     BEGIN_Positions();
  317.     BEGIN_TokenTab();
  318.     BEGIN_Errors();
  319.  
  320.     StartPrio = NIL;
  321.     WPrio = NIL;
  322.     RPrio = NIL;
  323.     INTOPERExists = FALSE;
  324.     ReadyForOperator = FALSE;
  325.     WOp = NIL;
  326.     ROp = NIL;
  327.     OpenForReading = FALSE;
  328.     GetOperatorAllowed = FALSE;
  329.     CurrentPrio = 0;
  330.   }
  331. }
  332.